import { defineStore } from 'pinia'
import { aiService, type AIModel } from '../services/ai-service'

// 模型状态接口
export interface ModelState {
  // 当前聊天模型
  currentChatModel: number
  // 当前图像模型
  currentImageModel: number
  // 当前模型ID
  currentModelId: number
  // 当前模型标签
  currentModelTags: string[]
  // 按标签存储的模型映射
  modelByTag: Record<string, number>
  // 模型列表
  models: AIModel[]
  // 模型加载状态
  modelsLoading: boolean
  // 模型加载错误
  modelsError: string | null
  // 最后加载时间
  modelsLastLoaded: number | null
  // 向量模型
  vectorModel: number
}

// 默认状态
const getDefaultState = (): ModelState => ({
  currentChatModel: 0, // 改为数字类型，初始化为0
  currentImageModel: 0, // 改为数字类型，初始化为0
  currentModelId: 0, // 当前模型ID，初始化为0
  currentModelTags: [],
  modelByTag: {},
  models: [], // 模型列表
  modelsLoading: false, // 加载状态
  modelsError: null, // 错误信息
  modelsLastLoaded: null, // 最后加载时间
  vectorModel: 0 // 改为数字类型，初始化为0
})

export const useModelStore = defineStore('model', {
  state: (): ModelState => getDefaultState(),
  
  getters: {
    // 获取指定标签的模型
    getModelByTag: (state) => (tag: string) => {
      return state.modelByTag[tag] || state.currentChatModel
    },
    
    // 获取所有模型配置
    allModels: (state) => ({
      chat: state.currentChatModel,
      image: state.currentImageModel,
      byTag: state.modelByTag
    }),
    
    // 获取按类型过滤的模型列表
    getModelsByTag: (state) => (type: string) => {
      if (!type) return state.models
      return state.models.filter(model => 
        model.type && model.type === type
      )
    },
    
    // 根据模型类型获取模型列表（新增方法）
    getModelsByType: (state) => (type: string) => {
      if (!type) return state.models
      return state.models.filter(model => 
        model.type && model.type === type
      )
    },
    
    // 获取模型选项（用于下拉选择）
    modelOptions: (state) => {
      return state.models.map(model => ({
        label: model.name,
        value: model.id,
        icon: model.icon,
        tags: model.tags ? (typeof model.tags === 'string' ? model.tags.split(',').map(tag => tag.trim()).filter(tag => tag !== '') : model.tags) : []
      }))
    },
    
    // 检查模型是否需要刷新（5分钟内的缓存视为有效）
    needsRefresh: (state) => {
      if (!state.modelsLastLoaded) return true
      const now = Date.now()
      const fiveMinutes = 5 * 60 * 1000
      return (now - state.modelsLastLoaded) > fiveMinutes
    }
  },
  
  actions: {
    // 设置当前聊天模型
    setCurrentChatModel(model: string | number) {
      this.currentChatModel = Number(model)
    },
    
    // 设置当前图像模型
    setCurrentImageModel(model: string | number) {
      this.currentImageModel = Number(model)
    },
    
    // 设置当前模型ID
    setCurrentModelId(modelId: string | number) {
      this.currentModelId = Number(modelId)
    },
    
    // 设置指定标签的模型
    setModelByTag(tag: string, model: string | number) {
      this.modelByTag[tag] = Number(model)
    },
    
    // 设置当前模型标签
    setCurrentModelTags(tags: string | string[]) {
      // 如果tags是字符串，则按逗号分割成数组
      if (typeof tags === 'string') {
        this.currentModelTags = tags.split(',').map(tag => tag.trim()).filter(tag => tag !== '')
      } else {
        this.currentModelTags = tags
      }
    },
    
    // 设置向量模型
    setVectorModel(model: string | number) {
      this.vectorModel = Number(model)
    },
    
    // 批量设置模型配置
    setModels(models: Partial<ModelState>) {
      Object.assign(this, models)
    },
    
    // 重置模型状态
    resetModelState() {
      Object.assign(this, getDefaultState())
    },
    
    // 加载模型列表
async loadModels(forceRefresh = false) {
  // 如果正在加载，直接返回
  if (this.modelsLoading) {
    console.log('ModelStore: 模型正在加载中，跳过重复加载')
    return this.models
  }
  
  // 如果不需要刷新且已有模型数据，直接返回
  if (!forceRefresh && !this.needsRefresh && this.models.length > 0) {
    console.log('ModelStore: 使用缓存的模型数据，共', this.models.length, '个模型')
    return this.models
  }
  
  this.modelsLoading = true
  this.modelsError = null
  
  try {
    console.log('ModelStore: 开始请求模型列表')
    const response = await aiService.getAiModels()
    console.log('ModelStore: 获取到模型列表响应', response)
    
    // base-service已经将RestVO格式转换为ApiResponse格式
    // 所以这里直接使用response.data即可
    if (response && response.code === 0 && Array.isArray(response.data)) {
      this.models = response.data
      this.modelsLastLoaded = Date.now()
      console.log('ModelStore: 成功加载模型列表，共', this.models.length, '个模型')
      
      // 如果没有当前模型，设置第一个为默认模型
      if (this.currentChatModel === 0 && this.models.length > 0) {
        this.setCurrentChatModel(this.models[0].id)
        this.setModelByTag('对话', this.models[0].id)
        console.log('ModelStore: 设置第一个模型为默认聊天模型', this.models[0].id)
      }
      
      return this.models
    } else {
      const errorMsg = response?.msg || '获取模型列表失败'
      console.error('ModelStore: 获取模型列表失败，响应格式不正确', response)
      throw new Error(errorMsg)
    }
  } catch (error) {
    this.modelsError = error instanceof Error ? error.message : '未知错误'
    console.error('ModelStore: 加载模型列表失败:', error)
    throw error
  } finally {
    this.modelsLoading = false
  }
},
    
    // 根据ID获取模型
    getModelById(id: string | number) {
      const idNum = Number(id)
      return this.models.find(model => model.id === idNum)
    }
  },
  
  // 配置持久化
  persist: {
    key: 'model-store',
    storage: localStorage,
    pick: [
      'currentChatModel',
      'currentImageModel',
      'currentModelId',
      'currentModelTags',
      'modelByTag',
      'models',
      'modelsLastLoaded',
      'vectorModel'
    ]
  }
})

// 导出模型存储类型
export type ModelStore = ReturnType<typeof useModelStore>